// Vika API 配置
const VIKA_CONFIG = {
    baseUrl: 'https://api.vika.cn/fusion/v1',
    token: 'usk3L5CcGGTqFaJllHYE6BA',
    datasheetId: 'dstYgzbt7uSqEoueKG'
};

// 全局变量
let allAnnouncements = []; // 存储所有公告数据
let filteredAnnouncements = []; // 存储过滤后的数据
let currentSearchTerm = ''; // 当前搜索词
let autoRefreshInterval = null; // 自动刷新定时器
let lastUpdateTime = null; // 最后更新时间
let dataHash = ''; // 数据哈希值，用于检测变化

// DOM 元素
const loadingState = document.getElementById('loadingState');
const errorState = document.getElementById('errorState');
const noDataState = document.getElementById('noDataState');
const announcementList = document.getElementById('announcementList');
const searchInput = document.getElementById('searchInput');
const retryButton = document.getElementById('retryButton');

// 创建刷新状态显示元素
function createRefreshStatus() {
    const refreshStatus = document.createElement('div');
    refreshStatus.id = 'refreshStatus';
    refreshStatus.style.cssText = `
        position: fixed;
        top: 10px;
        right: 10px;
        background: rgba(0, 0, 0, 0.8);
        color: white;
        padding: 8px 12px;
        border-radius: 4px;
        font-size: 12px;
        z-index: 1000;
        display: none;
    `;
    document.body.appendChild(refreshStatus);
    return refreshStatus;
}

const refreshStatus = createRefreshStatus();

// 应用初始化
document.addEventListener('DOMContentLoaded', async () => {
    console.log('应用初始化开始...');
    
    // 绑定事件监听器
    bindEventListeners();
    
    // 加载数据
    await loadAnnouncements();
    
    // 启动自动刷新
    startAutoRefresh();
    
    // 显示初始状态
    showRefreshStatus('应用已启动，数据将每30秒自动刷新');
});

// 绑定事件监听器
function bindEventListeners() {
    // 搜索输入事件
    searchInput.addEventListener('input', handleSearch);
    
    // 重试按钮事件
    retryButton.addEventListener('click', () => {
        loadAnnouncements(true); // 手动刷新
    });
    
    // 键盘快捷键
    document.addEventListener('keydown', (e) => {
        if (e.ctrlKey && e.key === 'f') {
            e.preventDefault();
            searchInput.focus();
        }
        if (e.key === 'F5') {
            e.preventDefault();
            loadAnnouncements(true); // 手动刷新
        }
        if (e.ctrlKey && e.key === 'r') {
            e.preventDefault();
            loadAnnouncements(true); // Ctrl+R 手动刷新
        }
    });
    
    // 窗口获得焦点时刷新数据
    window.addEventListener('focus', () => {
        console.log('窗口获得焦点，检查数据更新...');
        loadAnnouncements(false); // 静默刷新
    });
}

// 加载公告数据
async function loadAnnouncements(isManualRefresh = false) {
    console.log('开始加载公告数据...', isManualRefresh ? '(手动刷新)' : '(自动刷新)');
    
    // 如果是手动刷新，显示加载状态
    if (isManualRefresh) {
        showLoadingState();
    }
    
    try {
        const response = await fetch(`${VIKA_CONFIG.baseUrl}/datasheets/${VIKA_CONFIG.datasheetId}/records?fieldKey=name`, {
            method: 'GET',
            headers: {
                'Authorization': `Bearer ${VIKA_CONFIG.token}`,
                'Content-Type': 'application/json'
            }
        });

        if (!response.ok) {
            throw new Error(`HTTP Error: ${response.status} ${response.statusText}`);
        }

        const data = await response.json();
        console.log('API响应数据:', data);

        if (data.success && data.data && data.data.records) {
            // 计算数据哈希值
            const newDataHash = generateDataHash(data.data.records);
            
            // 检查数据是否发生变化
            if (newDataHash !== dataHash || allAnnouncements.length === 0) {
                console.log('数据发生变化，更新界面...');
                
                allAnnouncements = processAnnouncementData(data.data.records);
                dataHash = newDataHash;
                lastUpdateTime = new Date();
                
                console.log('处理后的公告数据:', allAnnouncements);
                
                // 应用过滤和搜索
                applyFiltersAndSearch();
                
                // 显示更新状态
                if (isManualRefresh) {
                    showRefreshStatus('数据已更新 - ' + formatTime(lastUpdateTime));
                } else {
                    showRefreshStatus('数据自动更新 - ' + formatTime(lastUpdateTime));
                }
            } else {
                console.log('数据无变化，跳过更新');
                if (isManualRefresh) {
                    showRefreshStatus('数据已是最新 - ' + formatTime(lastUpdateTime || new Date()));
                }
            }
            
        } else {
            throw new Error('API响应格式不正确或无数据');
        }

    } catch (error) {
        console.error('加载数据失败:', error);
        if (isManualRefresh) {
            showErrorState(error.message);
        } else {
            // 自动刷新失败时不显示错误状态，只记录日志
            console.warn('自动刷新失败，将在下次刷新时重试');
            showRefreshStatus('网络连接失败，将自动重试...');
        }
    }
}

// 生成数据哈希值（用于检测数据变化）
function generateDataHash(records) {
    const dataString = JSON.stringify(records.map(record => ({
        id: record.recordId,
        fields: record.fields
    })));
    
    // 简单的哈希算法
    let hash = 0;
    for (let i = 0; i < dataString.length; i++) {
        const char = dataString.charCodeAt(i);
        hash = ((hash << 5) - hash) + char;
        hash = hash & hash; // 转换为32位整数
    }
    return hash.toString();
}

// 启动自动刷新
function startAutoRefresh() {
    // 清除之前的定时器
    if (autoRefreshInterval) {
        clearInterval(autoRefreshInterval);
    }
    
    // 设置新的定时器，每30秒刷新一次
    autoRefreshInterval = setInterval(() => {
        console.log('自动刷新数据...');
        loadAnnouncements(false); // 自动刷新
    }, 30000); // 30秒
    
    console.log('自动刷新已启动，间隔：30秒');
}

// 停止自动刷新
function stopAutoRefresh() {
    if (autoRefreshInterval) {
        clearInterval(autoRefreshInterval);
        autoRefreshInterval = null;
        console.log('自动刷新已停止');
    }
}

// 显示刷新状态
function showRefreshStatus(message, duration = 3000) {
    refreshStatus.textContent = message;
    refreshStatus.style.display = 'block';
    
    // 自动隐藏
    setTimeout(() => {
        refreshStatus.style.display = 'none';
    }, duration);
}

// 格式化时间
function formatTime(date) {
    if (!date) return '';
    const hours = String(date.getHours()).padStart(2, '0');
    const minutes = String(date.getMinutes()).padStart(2, '0');
    const seconds = String(date.getSeconds()).padStart(2, '0');
    return `${hours}:${minutes}:${seconds}`;
}
function processAnnouncementData(records) {
    const processedData = records.map(record => {
        const fields = record.fields || {};
        
        // 调试输出，查看实际的字段名称
        console.log('字段名称:', Object.keys(fields));
        console.log('字段值:', fields);
        
        return {
            id: record.recordId,
            examName: fields['公告标题'] || '',
            examType: fields['考试类型'] || '',
            workLocation: fields['工作地点'] || '',
            contractType: fields['编制类型'] || '',
            recruitCount: fields['招录人数'] || '',
            deadline: fields['报名截止'] || '',
            examTime: fields['考试时间'] || '',
            officialWebsite: fields['公告链接'] || '',
            remarks: fields['备注'] || '',
            positionDetailsFile: fields['职位详情文件'] || null,
            // 隐藏字段（用于搜索）
            educationRequirement: fields['学历要求'] || '',
            majorRequirement: fields['专业要求'] || ''
        };
    });
    
    // 预先解析职位详情文件用于搜索
    processedData.forEach(announcement => {
        if (announcement.positionDetailsFile && 
            Array.isArray(announcement.positionDetailsFile) && 
            announcement.positionDetailsFile.length > 0) {
            // 异步解析职位详情文件
            parsePositionDetailsForSearch(announcement);
        }
    });
    
    return processedData;
}

// 应用过滤和搜索
function applyFiltersAndSearch() {
    console.log('应用过滤和搜索...');
    console.log('当前搜索词:', currentSearchTerm);
    
    // 检查是否有搜索词
    const hasSearchTerm = currentSearchTerm.trim().length > 0;
    
    if (hasSearchTerm) {
        // 有搜索词时，先应用时间过滤，再应用搜索过滤
        let timeFiltered = filterByDeadline(allAnnouncements);
        console.log('时间过滤后的公告数量:', timeFiltered.length);
        
        let searchFiltered = filterBySearch(timeFiltered, currentSearchTerm);
        console.log('搜索过滤后的公告数量:', searchFiltered.length);
        
        filteredAnnouncements = searchFiltered;
        
        console.log('最终搜索结果:', filteredAnnouncements.length, '条公告');
    } else {
        // 没有搜索词时，显示所有符合时间条件的公告
        filteredAnnouncements = filterByDeadline(allAnnouncements);
        console.log('无搜索词，显示所有有效公告:', filteredAnnouncements.length, '条');
    }
    
    // 渲染结果
    renderAnnouncements();
}

// 时间过滤函数
function filterByDeadline(announcements) {
    const now = new Date();
    // 设置当前时间为当天的23:59:59，这样当天截止的公告也能显示
    const todayEnd = new Date(now.getFullYear(), now.getMonth(), now.getDate(), 23, 59, 59);
    
    return announcements.filter(announcement => {
        // 确保deadline是字符串类型
        const deadline = String(announcement.deadline || '').trim();
        
        // 如果是"招满为止"，则始终显示
        if (deadline === '招满为止' || deadline.includes('招满为止')) {
            return true;
        }
        
        // 尝试解析日期
        const deadlineDate = parseDeadlineDate(deadline);
        if (deadlineDate) {
            // 设置截止日期为当天的23:59:59
            const deadlineEnd = new Date(deadlineDate.getFullYear(), deadlineDate.getMonth(), deadlineDate.getDate(), 23, 59, 59);
            return deadlineEnd >= now; // 使用当前精确时间比较
        }
        
        // 如果无法解析日期，则显示（保险起见）
        return true;
    });
}

// 解析截止日期
function parseDeadlineDate(dateStr) {
    if (!dateStr || String(dateStr).trim() === '') return null;
    
    try {
        // 确保是字符串类型
        const str = String(dateStr).trim();
        
        // 处理各种日期格式
        const cleanStr = str.replace(/[年月]/g, '-').replace(/[日]/g, '').trim();
        const date = new Date(cleanStr);
        
        if (isNaN(date.getTime())) {
            // 尝试其他格式
            const patterns = [
                /(\d{4})-(\d{1,2})-(\d{1,2})/,
                /(\d{4})\/(\d{1,2})\/(\d{1,2})/,
                /(\d{1,2})-(\d{1,2})-(\d{4})/,
                /(\d{1,2})\/(\d{1,2})\/(\d{4})/
            ];
            
            for (const pattern of patterns) {
                const match = str.match(pattern);
                if (match) {
                    const [, p1, p2, p3] = match;
                    // 根据第一个数字的长度判断年份位置
                    if (p1.length === 4) {
                        return new Date(parseInt(p1), parseInt(p2) - 1, parseInt(p3));
                    } else if (p3.length === 4) {
                        return new Date(parseInt(p3), parseInt(p2) - 1, parseInt(p1));
                    }
                }
            }
            return null;
        }
        
        return date;
    } catch (e) {
        console.warn('日期解析失败:', dateStr, e);
        return null;
    }
}

// 搜索过滤函数
function filterBySearch(announcements, searchTerm) {
    if (!searchTerm.trim()) {
        console.log('搜索词为空，返回所有公告');
        return announcements;
    }
    
    console.log('搜索词:', searchTerm);
    console.log('待搜索公告数量:', announcements.length);
    
    const terms = searchTerm.toLowerCase().split(/\s+/).filter(t => t.length > 0);
    console.log('分词结果:', terms);
    
    const results = announcements.filter(announcement => {
        // 组合所有可搜索的字段
        const searchableText = [
            announcement.examName,
            announcement.examType,
            announcement.workLocation,
            announcement.contractType,
            announcement.educationRequirement,
            announcement.majorRequirement,
            announcement.remarks
        ].join(' ').toLowerCase();
        
        // 添加职位详情文件中的内容
        const positionDetailsText = getPositionDetailsSearchText(announcement);
        const fullSearchableText = searchableText + ' ' + positionDetailsText;
        
        // 检查是否包含所有搜索词
        const matches = terms.every(term => fullSearchableText.includes(term));
        
        if (matches) {
            console.log('匹配的公告:', announcement.examName);
        }
        
        return matches;
    });
    
    console.log('搜索结果数量:', results.length);
    return results;
}

// 获取职位详情文件中的可搜索文本
function getPositionDetailsSearchText(announcement) {
    // 检查是否有职位详情文件
    if (!announcement.positionDetailsFile || 
        !Array.isArray(announcement.positionDetailsFile) || 
        announcement.positionDetailsFile.length === 0) {
        return '';
    }
    
    // 如果已经缓存了解析后的数据，直接使用
    if (announcement._positionDetailsCache) {
        return announcement._positionDetailsCache;
    }
    
    // 异步解析文件内容并缓存结果
    parsePositionDetailsForSearch(announcement);
    
    // 返回空字符串，等待异步解析完成后再次搜索
    return '';
}

// 异步解析职位详情文件用于搜索
function parsePositionDetailsForSearch(announcement) {
    const fileInfo = announcement.positionDetailsFile[0];
    if (!fileInfo.url) {
        announcement._positionDetailsCache = '';
        return;
    }
    
    // 防止重复解析
    if (announcement._parsingInProgress) {
        return;
    }
    announcement._parsingInProgress = true;
    
    // 使用fetch获取文件并解析
    fetch(fileInfo.url)
        .then(response => {
            if (!response.ok) {
                throw new Error('文件加载失败');
            }
            return response.arrayBuffer();
        })
        .then(data => {
            return parseExcelFile(data);
        })
        .then(parsedData => {
            // 提取所有的学历要求和专业要求文本
            const searchableContent = [];
            
            if (parsedData && Array.isArray(parsedData)) {
                parsedData.forEach(row => {
                    if (row.position) searchableContent.push(row.position);
                    if (row.education) searchableContent.push(row.education);
                    if (row.major) searchableContent.push(row.major);
                });
            }
            
            // 缓存解析结果
            announcement._positionDetailsCache = searchableContent.join(' ').toLowerCase();
            announcement._parsingInProgress = false;
            
            // 如果当前有搜索词，重新执行搜索
            if (currentSearchTerm.trim()) {
                setTimeout(() => {
                    applyFiltersAndSearch();
                }, 100); // 稍微延迟以避免频繁重新搜索
            }
        })
        .catch(error => {
            console.error('职位详情文件解析失败:', error);
            announcement._positionDetailsCache = '';
            announcement._parsingInProgress = false;
        });
}

// 处理搜索输入
function handleSearch(event) {
    currentSearchTerm = event.target.value;
    applyFiltersAndSearch();
}

// 渲染公告列表
function renderAnnouncements() {
    hideAllStates();
    
    if (filteredAnnouncements.length === 0) {
        showNoDataState();
        return;
    }
    
    // 清空现有内容
    announcementList.innerHTML = '';
    
    // 渲染每个公告卡片
    filteredAnnouncements.forEach((announcement, index) => {
        const cardElement = createAnnouncementCard(announcement, index);
        announcementList.appendChild(cardElement);
    });
    
    console.log(`渲染完成，显示 ${filteredAnnouncements.length} 条公告`);
}

// 创建公告卡片
function createAnnouncementCard(announcement, index) {
    const card = document.createElement('div');
    card.className = 'announcement-card';
    card.style.animationDelay = `${index * 0.1}s`;
    
    // 判断截止时间状态
    const deadlineStatus = getDeadlineStatus(announcement.deadline);
    
    card.innerHTML = `
        <div class="card-title">
            <span>${escapeHtml(announcement.examName)}</span>
            ${announcement.examType ? `<span class="exam-type-tag">${escapeHtml(announcement.examType)}</span>` : ''}
        </div>
        <div class="card-content">
            ${createInfoRow('工作地点', announcement.workLocation)}
            ${createInfoRow('编制类型', announcement.contractType)}
            ${createInfoRow('招录人数', announcement.recruitCount)}
            ${createDeadlineRow(announcement.deadline, deadlineStatus)}
            ${createInfoRow('考试时间', announcement.examTime)}
            ${announcement.remarks ? createInfoRow('备注', announcement.remarks) : ''}
        </div>
    `;
    
    // 添加点击事件监听器
    const actionButtons = card.querySelectorAll('.action-button');
    actionButtons.forEach(button => {
        button.addEventListener('click', (e) => {
            const action = e.target.getAttribute('data-action');
            if (action === 'original') {
                copyAnnouncementLink(announcement.officialWebsite, e.target);
            } else if (action === 'details') {
                showPositionDetails(announcement);
            }
        });
    });
    
    return card;
}

// 创建信息行
function createInfoRow(label, value) {
    // 为招录人数添加特殊处理
    const isRecruitCount = label === '招录人数';
    let displayValue;
    
    if (isRecruitCount) {
        // 招录人数字段特殊处理，不依赖字符串转换
        displayValue = formatRecruitCount(value);
    } else {
        // 其他字段正常处理
        const stringValue = String(value || '').trim();
        if (!stringValue) return '';
        displayValue = stringValue;
    }
    
    const valueClass = isRecruitCount ? 'recruit-count-value' : '';
    
    return `
        <div class="info-row">
            <span class="info-label">${label}</span>
            <span class="info-value ${valueClass}">${escapeHtml(displayValue)}</span>
        </div>
    `;
}

// 格式化招录人数显示
function formatRecruitCount(recruitCount) {
    // 处理空值或未定义
    if (recruitCount === null || recruitCount === undefined || recruitCount === '') {
        return '未知';
    }
    
    // 将值转换为数字进行比较
    const numValue = Number(recruitCount);
    
    // 处理数字-1（后台存储的"未知"标识）
    if (numValue === -1) {
        return '未知';
    }
    
    // 处理字符串"未知"
    const stringValue = String(recruitCount).trim();
    if (stringValue === '未知') {
        return '未知';
    }
    
    // 处理正常数字
    if (isNaN(numValue) || numValue <= 0) {
        return '未知';
    }
    
    return `${numValue}人`;
}

// 创建截止时间行
function createDeadlineRow(deadline, status) {
    // 确保截止时间是字符串类型
    const stringDeadline = String(deadline || '').trim();
    
    // 即使为空也显示字段
    const displayDeadline = stringDeadline || '待定';
    const isUnlimited = stringDeadline.includes('招满为止');
    let className = 'deadline-info';
    
    if (isUnlimited) {
        className = 'deadline-unlimited';
    } else if (!stringDeadline) {
        className = 'deadline-pending';
    }
    
    return `
        <div class="info-row deadline-row">
            <span class="info-label">报名截止</span>
            <span class="info-value ${className}">${escapeHtml(displayDeadline)}</span>
            <div class="card-actions">
                <button class="action-button" data-action="details">
                    职位详情
                </button>
                <button class="action-button" data-action="original">
                    原公告
                </button>
            </div>
        </div>
    `;
}

// 复制公告链接功能
async function copyAnnouncementLink(website, buttonElement) {
    // 确保网站地址是字符串类型并且不为空
    const stringWebsite = String(website || '').trim();
    
    if (!stringWebsite) {
        alert('公告链接不可用');
        return;
    }
    
    let url = stringWebsite;
    
    // 提取URL（如果文本中包含URL）
    const urlMatch = stringWebsite.match(/(https?:\/\/[^\s]+)/);
    if (urlMatch) {
        url = urlMatch[1];
    } else if (!stringWebsite.startsWith('http://') && !stringWebsite.startsWith('https://')) {
        alert('无效的公告链接');
        return;
    }
    
    try {
        // 使用Clipboard API复制链接
        await navigator.clipboard.writeText(url);
        showCopySuccess(buttonElement);
        console.log('公告链接已复制:', url);
        
    } catch (error) {
        console.error('复制链接失败:', error);
        
        // 如果Clipboard API不可用，使用备用方案
        try {
            const textArea = document.createElement('textarea');
            textArea.value = url;
            textArea.style.position = 'fixed';
            textArea.style.opacity = '0';
            document.body.appendChild(textArea);
            textArea.select();
            document.execCommand('copy');
            document.body.removeChild(textArea);
            
            showCopySuccess(buttonElement);
            console.log('公告链接已复制（备用方案）:', url);
            
        } catch (fallbackError) {
            console.error('备用复制方案也失败:', fallbackError);
            alert('无法复制链接，请手动复制：' + url);
        }
    }
}

// 显示复制成功状态
function showCopySuccess(buttonElement) {
    // 保存原始文本
    const originalText = buttonElement.textContent;
    
    // 更改按钮文本和样式
    buttonElement.textContent = '已复制';
    buttonElement.classList.add('copied');
    
    // 3秒后恢复原始状态
    setTimeout(() => {
        buttonElement.textContent = originalText;
        buttonElement.classList.remove('copied');
    }, 3000);
}

// 创建网站链接行
function createWebsiteRow(website) {
    // 确保网站地址是字符串类型并且不为空
    const stringWebsite = String(website || '').trim();
    if (!stringWebsite) return '';
    
    // 检查是否包含URL
    const urlMatch = stringWebsite.match(/(https?:\/\/[^\s]+)/);
    if (urlMatch) {
        const url = urlMatch[1];
        return `
            <div class="info-row">
                <span class="info-label">公告链接</span>
                <span class="info-value">
                    <a href="${escapeHtml(url)}" class="website-link" target="_blank" rel="noopener noreferrer">
                        查看公告
                    </a>
                </span>
            </div>
        `;
    }
    
    // 如果是纯链接格式
    if (stringWebsite.startsWith('http://') || stringWebsite.startsWith('https://')) {
        return `
            <div class="info-row">
                <span class="info-label">公告链接</span>
                <span class="info-value">
                    <a href="${escapeHtml(stringWebsite)}" class="website-link" target="_blank" rel="noopener noreferrer">
                        查看公告
                    </a>
                </span>
            </div>
        `;
    }
    
    // 如果不是URL，不显示链接行
    return '';
}

// 获取截止时间状态
function getDeadlineStatus(deadline) {
    // 确保截止时间是字符串类型
    const stringDeadline = String(deadline || '').trim();
    if (!stringDeadline) return 'unknown';
    
    if (stringDeadline.includes('招满为止')) return 'unlimited';
    
    const deadlineDate = parseDeadlineDate(stringDeadline);
    if (!deadlineDate) return 'unknown';
    
    const now = new Date();
    const diffDays = Math.ceil((deadlineDate - now) / (1000 * 60 * 60 * 24));
    
    if (diffDays < 0) return 'expired';
    if (diffDays <= 3) return 'urgent';
    if (diffDays <= 7) return 'warning';
    return 'normal';
}

// 显示/隐藏状态
function showLoadingState() {
    hideAllStates();
    loadingState.style.display = 'flex';
}

function showErrorState(message) {
    hideAllStates();
    document.getElementById('errorMessage').textContent = message || '加载失败，请检查网络连接';
    errorState.style.display = 'flex';
}

function showNoDataState() {
    hideAllStates();
    
    // 根据是否有搜索词显示不同的提示信息
    const hasSearchTerm = currentSearchTerm.trim().length > 0;
    const noDataElement = document.getElementById('noDataState');
    const messageElement = noDataElement.querySelector('p');
    
    if (hasSearchTerm) {
        // 有搜索词但没有结果
        messageElement.textContent = `未找到包含“${currentSearchTerm}”的内容`;
    } else {
        // 没有搜索词但没有数据
        messageElement.textContent = '暂无符合条件的考试公告';
    }
    
    noDataState.style.display = 'flex';
}

function hideAllStates() {
    loadingState.style.display = 'none';
    errorState.style.display = 'none';
    noDataState.style.display = 'none';
}

// 工具函数
function escapeHtml(unsafe) {
    if (typeof unsafe !== 'string') return '';
    return unsafe
        .replace(/&/g, "&amp;")
        .replace(/</g, "&lt;")
        .replace(/>/g, "&gt;")
        .replace(/"/g, "&quot;")
        .replace(/'/g, "&#039;");
}

// 导出函数供调试使用
window.examApp = {
    loadAnnouncements: (manual = true) => loadAnnouncements(manual),
    allAnnouncements: () => allAnnouncements,
    filteredAnnouncements: () => filteredAnnouncements,
    applyFiltersAndSearch,
    startAutoRefresh,
    stopAutoRefresh,
    refreshNow: () => loadAnnouncements(true),
    getLastUpdateTime: () => lastUpdateTime,
    getDataHash: () => dataHash,
    // 新增辅助解析函数
    testSpecialParse: (fileUrl) => {
        if (!fileUrl) {
            console.error('请提供文件URL');
            return;
        }
        
        console.log('开始测试特殊格式解析:', fileUrl);
        
        return fetch(fileUrl)
            .then(response => {
                if (!response.ok) {
                    throw new Error('文件加载失败');
                }
                return response.arrayBuffer();
            })
            .then(data => {
                const decoder = new TextDecoder('utf-8');
                let text = decoder.decode(data);
                
                // 判断是否有乱码，如果有尝试其他编码
                if (text.includes('�') || text.includes('�')) {
                    try {
                        const decoder2 = new TextDecoder('gbk');
                        text = decoder2.decode(data);
                    } catch(e) {
                        console.log('编码转换失败:', e);
                    }
                }
                
                console.log('文件解码完成，开始特殊解析');
                console.log('文件内容预览:', text.substring(0, 200));
                
                return parseSpecialExcelFormat(text);
            })
            .then(result => {
                console.log('特殊解析结果:', result);
                return result;
            })
            .catch(err => {
                console.error('特殊解析失败:', err);
                throw err;
            });
    }
};

// 职位详情弹窗功能
function showPositionDetails(announcement) {
    // 检查是否有职位详情文件
    if (!announcement.positionDetailsFile || !Array.isArray(announcement.positionDetailsFile) || announcement.positionDetailsFile.length === 0) {
        alert('该公告暂无职位详情文件');
        return;
    }
    
    // 获取文件信息
    const fileInfo = announcement.positionDetailsFile[0];
    
    if (!fileInfo.url) {
        alert('职位详情文件链接不可用');
        return;
    }
    
    // 创建弹窗
    createPositionDetailsModal(announcement, fileInfo);
}

// 创建职位详情弹窗
function createPositionDetailsModal(announcement, fileInfo) {
    // 检查是否已存在弹窗
    let modal = document.getElementById('positionDetailsModal');
    if (modal) {
        modal.remove();
    }
    
    // 创建弹窗元素
    modal = document.createElement('div');
    modal.id = 'positionDetailsModal';
    modal.className = 'position-details-modal';
    
    // 计算弹窗大小（95%）
    const windowWidth = window.innerWidth;
    const windowHeight = window.innerHeight;
    const modalWidth = Math.floor(windowWidth * 0.95);
    const modalHeight = Math.floor(windowHeight * 0.95);
    
    modal.innerHTML = `
        <div class="modal-overlay" onclick="closePositionDetailsModal()">
            <div class="modal-content" onclick="event.stopPropagation()" style="width: ${modalWidth}px; height: ${modalHeight}px;">
                <div class="modal-header">
                    <h2>职位详情 - ${escapeHtml(announcement.examName)}</h2>
                    <button class="modal-close-btn" onclick="closePositionDetailsModal()">&times;</button>
                </div>
                <div class="modal-body">
                    <div id="excelPreview_${announcement.id}" class="excel-preview">
                        <div class="loading-preview">
                            <div class="loading-spinner active"></div>
                            <p>正在加载职位详情...</p>
                        </div>
                    </div>
                </div>
            </div>
        </div>
    `;
    
    // 添加到页面
    document.body.appendChild(modal);
    
    // 显示弹窗动画
    setTimeout(() => {
        modal.style.opacity = '1';
        // 直接加载表格预览
        loadExcelPreview(fileInfo.url, announcement.id);
    }, 10);
    
    // ESC键关闭弹窗
    const handleEscKey = (e) => {
        if (e.key === 'Escape') {
            closePositionDetailsModal();
        }
    };
    document.addEventListener('keydown', handleEscKey);
    
    // 保存事件监听器以便后续清理
    modal._escKeyHandler = handleEscKey;
}

// 关闭职位详情弹窗
function closePositionDetailsModal() {
    const modal = document.getElementById('positionDetailsModal');
    if (modal) {
        // 清理事件监听器
        if (modal._escKeyHandler) {
            document.removeEventListener('keydown', modal._escKeyHandler);
        }
        
        // 关闭动画
        modal.style.opacity = '0';
        setTimeout(() => {
            modal.remove();
        }, 300);
    }
}

// 加载Excel预览功能
function loadExcelPreview(fileUrl, announcementId) {
    console.log('开始加载Excel预览，文件URL:', fileUrl, '公告ID:', announcementId);
    
    const previewContainer = document.getElementById(`excelPreview_${announcementId}`);
    if (!previewContainer) {
        console.error('找不到预览容器，ID:', `excelPreview_${announcementId}`);
        return;
    }
    
    // 显示加载状态
    previewContainer.innerHTML = `
        <div class="loading-preview">
            <div class="loading-spinner active"></div>
            <p>正在加载表格数据...</p>
        </div>
    `;
    
    // 确保SheetJS库已加载
    ensureSheetJSLoaded().then((success) => {
        console.log('SheetJS库加载结果:', success);
        if (success) {
            // SheetJS库已加载，解析文件
            console.log('使用SheetJS库解析文件');
            fetchAndRenderExcel(fileUrl, previewContainer);
        } else {
            // 无法加载SheetJS库，使用备用方案
            console.log('SheetJS库加载失败，使用备用解析方案');
            fetch(fileUrl)
                .then(response => {
                    console.log('文件获取响应状态:', response.status);
                    if (!response.ok) {
                        throw new Error('文件加载失败: ' + response.status + ' ' + response.statusText);
                    }
                    return response.arrayBuffer();
                })
                .then(data => {
                    console.log('开始解析文件数据，大小:', data.byteLength);
                    return parseExcelFile(data);
                })
                .then(parsedData => {
                    console.log('文件解析完成，数据行数:', parsedData.length);
                    displayExcelData(parsedData, previewContainer);
                })
                .catch(error => {
                    console.error('文件解析错误:', error);
                    displayFallbackData(previewContainer);
                });
        }
    }).catch(error => {
        console.error('确保SheetJS库加载时出错:', error);
        displayFallbackData(previewContainer);
    });
}

// 获取并渲染Excel文件 - 改进版本，专门处理中文编码问题
function fetchAndRenderExcel(fileUrl, container) {
    console.log('开始获取并渲染Excel文件:', fileUrl);
    
    // 使用fetch获取文件
    fetch(fileUrl)
        .then(response => {
            console.log('文件响应状态:', response.status, response.statusText);
            if (!response.ok) {
                throw new Error('文件加载失败: ' + response.status + ' ' + response.statusText);
            }
            return response.arrayBuffer();
        })
        .then(data => {
            try {
                console.log('文件大小:', data.byteLength, 'bytes');
                
                // 检查数据是否有效
                if (!data || data.byteLength === 0) {
                    throw new Error('文件数据为空');
                }
                
                // 检查是否已加载SheetJS库
                if (typeof XLSX === 'undefined') {
                    throw new Error('SheetJS库未加载');
                }
                
                // 特别处理中文Excel文件的编码问题
                // 尝试多种编码选项来解析Excel文件
                let workbook;
                const encodingOptions = [
                    { codepage: 936, WTF: false }, // 简体中文
                    { codepage: 936, WTF: true }, // 简体中文 + WTF模式
                    { codepage: 950, WTF: false }, // 繁体中文
                    { codepage: 65001, WTF: false }, // UTF-8
                    { bookType: 'xlsx', bookSST: false, WTF: false }, // 默认选项
                    { }, // 完全默认选项
                ];
                
                let lastError;
                let usedOptions = null;
                
                for (const options of encodingOptions) {
                    try {
                        console.log('尝试使用编码选项:', options);
                        workbook = XLSX.read(data, {
                            type: 'array',
                            cellNF: false,
                            cellHTML: true,
                            cellStyles: false,
                            ...options
                        });
                        console.log('使用编码选项成功:', options);
                        usedOptions = options;
                        lastError = null;
                        break;
                    } catch (encodingError) {
                        console.log('编码选项失败:', options, encodingError.message);
                        lastError = encodingError;
                    }
                }
                
                if (!workbook && lastError) {
                    throw lastError;
                }
                
                console.log('工作簿解析完成，工作表数量:', workbook.SheetNames.length);
                console.log('使用的编码选项:', usedOptions);
                
                // 获取第一个工作表
                if (workbook.SheetNames.length === 0) {
                    throw new Error('工作簿中没有工作表');
                }
                
                const firstSheetName = workbook.SheetNames[0];
                console.log('第一个工作表名称:', firstSheetName);
                
                const worksheet = workbook.Sheets[firstSheetName];
                if (!worksheet) {
                    throw new Error('无法获取工作表数据');
                }
                
                // 特别处理HTML转换以确保中文正确显示
                let html;
                const htmlOptions = [
                    { raw: true, cellNF: false, blankrows: false },
                    { raw: false, cellNF: false, blankrows: false },
                    { raw: true, cellNF: false, blankrows: false, WTF: true },
                    { editable: false, raw: true }, // 默认选项
                ];
                
                let htmlLastError;
                let usedHtmlOptions = null;
                
                for (const options of htmlOptions) {
                    try {
                        console.log('尝试HTML转换选项:', options);
                        html = XLSX.utils.sheet_to_html(worksheet, options);
                        console.log('HTML转换成功，长度:', html.length);
                        if (html && html.length > 0) {
                            usedHtmlOptions = options;
                            htmlLastError = null;
                            break;
                        }
                    } catch (htmlError) {
                        console.log('HTML转换选项失败:', options, htmlError.message);
                        htmlLastError = htmlError;
                    }
                }
                
                if ((!html || html.length === 0) && htmlLastError) {
                    throw htmlLastError;
                }
                
                // 检查HTML是否有效
                if (!html || html.length === 0) {
                    throw new Error('转换后的HTML为空');
                }
                
                // 检查并修复可能的乱码问题
                // 移除可能的乱码字符
                html = html.replace(/[\uFFFD\uFFFE\uFFFF]/g, '');
                
                // 创建完整的HTML内容
                const tableHtml = `
                    <div class="excel-table-container" style="height: 100%; overflow-y: auto;">
                        <!-- 置顶提示信息 -->
                        <div class="table-notice" style="background: #fff3cd; border: 1px solid #ffeaa7; border-radius: 4px 4px 0 0; padding: 12px; margin: 0; color: #856404; font-size: 14px; text-align: center; position: sticky; top: 0; z-index: 10; border-bottom: none;">
                            <strong>注意：</strong>此表为简化版，详情请查看官方原公告。
                        </div>
                        <div class="excel-html-container" style="padding: 0;">
                            ${html}
                        </div>
                        
                    </div>
                `;
                
                // 替换容器内容
                container.innerHTML = tableHtml;
                
                // 美化表格样式
                styleExcelTable(container);
                
                console.log('Excel文件渲染完成');
            } catch (error) {
                console.error('解析Excel文件出错:', error);
                // 如果SheetJS失败，尝试使用传统解析方法
                console.log('尝试使用传统解析方法');
                return parseExcelFile(data)
                    .then(parsedData => {
                        // 检查解析结果是否为提示信息
                        if (parsedData && parsedData.length > 0 && 
                            (parsedData[0].position === '文件格式提示' || 
                             parsedData[0].position === '解析失败' || 
                             parsedData[0].position === '解析错误')) {
                            // 显示提示信息
                            displayExcelData(parsedData, container);
                        } else {
                            // 正常显示数据
                            displayExcelData(parsedData, container);
                        }
                    })
                    .catch(parseError => {
                        console.error('传统解析方法也失败:', parseError);
                        displayFallbackData(container);
                    });
            }
        })
        .catch(error => {
            console.error('文件加载失败:', error);
            displayFallbackData(container);
        });
}

// 美化Excel表格样式
function styleExcelTable(container) {
    console.log('开始美化Excel表格样式');
    
    // 获取SheetJS生成的表格
    const table = container.querySelector('table');
    if (!table) {
        console.warn('未找到表格元素');
        return;
    }
    
    // 添加类名和样式
    table.className = 'excel-table';
    table.style.width = '100%';
    table.style.borderCollapse = 'collapse';
    table.style.fontSize = '14px';
    table.style.tableLayout = 'fixed'; // 固定表格布局
    
    // 设置列宽
    const colgroup = document.createElement('colgroup');
    const col1 = document.createElement('col');
    col1.style.width = '30%';
    const col2 = document.createElement('col');
    col2.style.width = '20%';
    const col3 = document.createElement('col');
    col3.style.width = '50%';
    colgroup.appendChild(col1);
    colgroup.appendChild(col2);
    colgroup.appendChild(col3);
    table.insertBefore(colgroup, table.firstChild);
    
    // 检测表头(第一行)
    const rows = table.querySelectorAll('tr');
    if (rows.length > 0) {
        const firstRow = rows[0];
        const cells = firstRow.querySelectorAll('td, th');
        
        // 将第一行的td转换为th（如果还不是th）
        cells.forEach(cell => {
            if (cell.tagName.toLowerCase() === 'td') {
                const th = document.createElement('th');
                th.innerHTML = cell.innerHTML;
                th.style.padding = '12px';
                th.style.border = '1px solid #ddd';
                th.style.background = '#f8f9fa';
                th.style.fontWeight = 'bold';
                th.style.textAlign = 'left';
                th.style.verticalAlign = 'top';
                th.style.wordWrap = 'break-word';
                cell.parentNode.replaceChild(th, cell);
            } else {
                // 如果已经是th，设置样式
                cell.style.padding = '12px';
                cell.style.border = '1px solid #ddd';
                cell.style.background = '#f8f9fa';
                cell.style.fontWeight = 'bold';
                cell.style.textAlign = 'left';
                cell.style.verticalAlign = 'top';
                cell.style.wordWrap = 'break-word';
            }
        });
    }
    
    // 美化其他所有单元格
    const allCells = table.querySelectorAll('td, th');
    allCells.forEach((cell, index) => {
        // 跳过已经处理过的表头单元格
        if (cell.tagName.toLowerCase() === 'th' && 
            cell.style.padding === '12px' && 
            cell.style.background === 'rgb(248, 249, 250)') {
            return;
        }
        
        cell.style.padding = '10px 12px';
        cell.style.border = '1px solid #ddd';
        cell.style.verticalAlign = 'top';
        cell.style.wordWrap = 'break-word';
        cell.style.overflowWrap = 'break-word';
        
        // 为偶数行添加背景色（跳过表头）
        const row = cell.parentElement;
        const rowIndex = Array.from(rows).indexOf(row);
        if (rowIndex > 0 && rowIndex % 2 === 1) {
            cell.style.backgroundColor = '#f8f9fa';
        }
    });
    
    console.log('Excel表格样式美化完成');
}

// 解析Excel/CSV文件函数 - 改进版本，专门处理中文编码问题
function parseExcelFile(arrayBuffer) {
    return new Promise((resolve, reject) => {
        try {
            // 检查是否已加载SheetJS库
            if (typeof XLSX !== 'undefined') {
                console.log('使用SheetJS库解析Excel文件');
                try {
                    // 特别处理中文Excel文件的编码问题
                    // 尝试多种编码选项来解析Excel文件
                    let workbook;
                    const encodingOptions = [
                        { codepage: 936, WTF: false }, // 简体中文
                        { codepage: 936, WTF: true }, // 简体中文 + WTF模式
                        { codepage: 950, WTF: false }, // 繁体中文
                        { codepage: 65001, WTF: false }, // UTF-8
                        { bookType: 'xlsx', bookSST: false, WTF: false }, // 默认选项
                        { }, // 完全默认选项
                    ];
                    
                    let lastError;
                    let usedOptions = null;
                    
                    for (const options of encodingOptions) {
                        try {
                            console.log('尝试使用编码选项:', options);
                            workbook = XLSX.read(arrayBuffer, {
                                type: 'array',
                                cellNF: false,
                                cellHTML: true,
                                cellStyles: false,
                                ...options
                            });
                            console.log('使用编码选项成功:', options);
                            usedOptions = options;
                            lastError = null;
                            break;
                        } catch (encodingError) {
                            console.log('编码选项失败:', options, encodingError.message);
                            lastError = encodingError;
                        }
                    }
                    
                    if (!workbook && lastError) {
                        throw lastError;
                    }
                    
                    console.log('工作簿解析完成，工作表数量:', workbook.SheetNames.length);
                    console.log('使用的编码选项:', usedOptions);
                    
                    // 获取第一个工作表
                    if (workbook.SheetNames.length === 0) {
                        throw new Error('工作簿中没有工作表');
                    }
                    
                    const firstSheetName = workbook.SheetNames[0];
                    const worksheet = workbook.Sheets[firstSheetName];
                    
                    // 特别处理JSON转换以确保中文正确显示
                    let jsonData;
                    const jsonOptions = [
                        { header: 1, raw: true, defval: '', blankrows: false },
                        { header: 1, raw: false, defval: '', blankrows: false },
                        { header: 1, raw: true, defval: '', blankrows: false, WTF: true },
                        { header: 1 }, // 默认选项
                    ];
                    
                    let jsonLastError;
                    let usedJsonOptions = null;
                    
                    for (const options of jsonOptions) {
                        try {
                            console.log('尝试JSON转换选项:', options);
                            jsonData = XLSX.utils.sheet_to_json(worksheet, options);
                            console.log('JSON转换成功，行数:', jsonData.length);
                            if (jsonData && jsonData.length > 0) {
                                usedJsonOptions = options;
                                jsonLastError = null;
                                break;
                            }
                        } catch (jsonError) {
                            console.log('JSON转换选项失败:', options, jsonError.message);
                            jsonLastError = jsonError;
                        }
                    }
                    
                    if ((!jsonData || jsonData.length === 0) && jsonLastError) {
                        throw jsonLastError;
                    }
                    
                    console.log('使用的JSON选项:', usedJsonOptions);
                    
                    // 转换为我们的数据格式
                    const result = [];
                    if (jsonData.length > 0) {
                        // 获取表头
                        const headers = jsonData[0];
                        console.log('表头:', headers);
                        
                        // 处理数据行
                        for (let i = 1; i < jsonData.length; i++) {
                            const row = jsonData[i];
                            if (row && row.length > 0) {
                                const rowData = {
                                    position: row[0] || '',
                                    education: row[1] || '',
                                    major: row[2] || ''
                                };
                                // 只添加非空行
                                if (rowData.position || rowData.education || rowData.major) {
                                    // 特别处理可能的乱码字符
                                    rowData.position = String(rowData.position).replace(/[\uFFFD\uFFFE\uFFFF]/g, '');
                                    rowData.education = String(rowData.education).replace(/[\uFFFD\uFFFE\uFFFF]/g, '');
                                    rowData.major = String(rowData.major).replace(/[\uFFFD\uFFFE\uFFFF]/g, '');
                                    result.push(rowData);
                                }
                            }
                        }
                    }
                    
                    console.log('SheetJS解析结果:', result);
                    resolve(result);
                    return;
                } catch (sheetError) {
                    console.error('SheetJS解析失败:', sheetError);
                    // 如果SheetJS解析失败，继续使用传统方法
                }
            }
            
            // 检测文件类型
            const uint8Array = new Uint8Array(arrayBuffer);
            const fileHeader = Array.from(uint8Array.slice(0, 8)).map(b => b.toString(16).padStart(2, '0')).join('');
            
            console.log('文件头部信息:', fileHeader);
            console.log('文件大小:', arrayBuffer.byteLength, 'bytes');
            
            // 首先尝试解析为文本数据（CSV）
            let csvText = '';
            let parseSuccess = false;
            
            // 尝试多种编码方式解析文件
            try {
                // 首先尝试UTF-8
                const decoder = new TextDecoder('utf-8');
                csvText = decoder.decode(arrayBuffer);
                // 检查是否有乱码
                if (!csvText.includes('\ufffd') && !csvText.includes('')) {
                    parseSuccess = true;
                }
            } catch (e) {
                console.log('UTF-8解码失败，尝试其他编码');
            }
            
            if (!parseSuccess) {
                // 尝试其他编码
                try {
                    const decoder = new TextDecoder('gbk');
                    csvText = decoder.decode(arrayBuffer);
                    parseSuccess = true;
                } catch (e2) {
                    try {
                        const decoder = new TextDecoder('gb2312');
                        csvText = decoder.decode(arrayBuffer);
                        parseSuccess = true;
                    } catch (e3) {
                        try {
                            // 最后尝试latin1
                            const decoder = new TextDecoder('iso-8859-1');
                            csvText = decoder.decode(arrayBuffer);
                            parseSuccess = true;
                        } catch (e4) {
                            console.log('所有编码尝试失败');
                        }
                    }
                }
            }
            
            if (!parseSuccess) {
                // 如果所有编码都失败，返回错误提示
                resolve([
                    {
                        position: '文件解析失败',
                        education: '无法读取文件内容',
                        major: '请检查文件格式'
                    }
                ]);
                return;
            }
            
            // 特别处理可能的乱码字符
            csvText = csvText.replace(/[\uFFFD\uFFFE\uFFFF]/g, '');
            
            console.log('CSV文本内容前100字符:', csvText.substring(0, 100));
            
            // 检查是否为二进制数据（如Excel文件）
            const hasControlChars = /[\x00-\x08\x0E-\x1F\x7F-\x9F]/.test(csvText.substring(0, 1000));
            const hasBinarySignature = fileHeader.startsWith('504b') || fileHeader.startsWith('d0cf11e0');
            
            if (hasBinarySignature || (hasControlChars && csvText.length > 500)) {
                // 对于二进制Excel文件，如果SheetJS库不可用，则显示转换提示
                if (typeof XLSX === 'undefined') {
                    console.log('检测到Excel文件格式，显示转换提示');
                    resolve([
                        {
                            position: '文件格式提示',
                            education: '检测到Excel格式',
                            major: '建议转为CSV格式'
                        },
                        {
                            position: '操作说明',
                            education: '1. 在Excel中打开文件',
                            major: '2. 另存为CSV格式'
                        },
                        {
                            position: '或者',
                            education: '直接上传CSV文件',
                            major: '获得最佳显示效果'
                        }
                    ]);
                    return;
                }
                // 如果SheetJS库可用，上面的代码已经处理了这种情况
            }

// 解析CSV行函数（处理引号包围的内容）
function parseCSVLine(line) {
    const result = [];
    let current = '';
    let inQuotes = false;
    let i = 0;
    
    while (i < line.length) {
        const char = line[i];
        
        if (char === '"' || char === "'") {
            if (inQuotes && line[i + 1] === char) {
                // 双引号转义
                current += char;
                i += 2;
            } else {
                inQuotes = !inQuotes;
                i++;
            }
        } else if (char === ',' && !inQuotes) {
            result.push(current.trim());
            current = '';
            i++;
        } else {
            current += char;
            i++;
        }
    }
    
    result.push(current.trim());
    return result;
}

// 智能分割行函数
function smartSplitLine(line) {
    // 尝试识别可能的分隔模式
    
    // 检查是否包含多个空格（可能是空格分隔）
    if (line.includes('  ')) {
        return line.split(/\s{2,}/).map(s => s.trim()).filter(s => s);
    }
    
    // 尝试按特定关键词分割（针对中文数据）
    const keywords = ['本科', '硕士', '博士', '专科', '不限'];
    for (const keyword of keywords) {
        if (line.includes(keyword)) {
            // 尝试以关键词为分界点分割
            const parts = line.split(new RegExp(`(${keyword}[^\s]*)`));
            if (parts.length >= 3) {
                const cleaned = parts.filter(p => p.trim()).map(p => p.trim());
                if (cleaned.length >= 2) {
                    return cleaned;
                }
            }
        }
    }
    
    // 如果以上都失败，返回整行作为一列
    return [line];
}

// 判断是否为标题行
function isHeaderRow(rowData) {
    const position = (rowData.position || '').toLowerCase();
    const education = (rowData.education || '').toLowerCase();
    const major = (rowData.major || '').toLowerCase();
    
    // 检查是否包含标题关键词
    const headerKeywords = ['职位名称', '岗位', '学历要求', '学历', '专业要求', '专业', 'position', 'education', 'major'];
    
    return headerKeywords.some(keyword => 
        position.includes(keyword) || 
        education.includes(keyword) || 
        major.includes(keyword)
    );
}
            
            // 解析CSV数据
            const lines = csvText.split(/\r?\n/).filter(line => line.trim());
            const data = [];
            
            console.log('总行数:', lines.length);
            console.log('前3行原始数据:', lines.slice(0, 3));
            
            for (let i = 0; i < lines.length; i++) {
                const line = lines[i].trim();
                if (!line) continue;
                
                console.log(`第${i+1}行原始数据:`, JSON.stringify(line));
                
                let cols = [];
                
                // 优先尝试制表符分隔（Excel复制粘贴通常使用制表符）
                if (line.includes('\t')) {
                    cols = line.split('\t');
                    console.log(`第${i+1}行制表符分割结果:`, cols.length, '列:', cols);
                } 
                // 然后尝试逗号分隔
                else if (line.includes(',')) {
                    // 处理CSV格式，支持引号包围的内容
                    cols = parseCSVLine(line);
                    console.log(`第${i+1}行逗号分割结果:`, cols.length, '列:', cols);
                } 
                // 中文逗号分隔
                else if (line.includes('，')) {
                    cols = line.split('，');
                    console.log(`第${i+1}行中文逗号分割结果:`, cols.length, '列:', cols);
                } 
                // 分号分隔
                else if (line.includes(';')) {
                    cols = line.split(';');
                    console.log(`第${i+1}行分号分割结果:`, cols.length, '列:', cols);
                } 
                // 最后尝试空格分隔（但要小心，因为职位名称可能包含空格）
                else {
                    // 对于无明显分隔符的行，尝试智能分割
                    cols = smartSplitLine(line);
                    console.log(`第${i+1}行智能分割结果:`, cols.length, '列:', cols);
                }
                
                // 清理列数据
                cols = cols.map(col => {
                    if (typeof col !== 'string') col = String(col);
                    return col.trim().replace(/^[""'']/g, '').replace(/[""'']$/g, '');
                }).filter(col => col.length > 0);
                
                console.log(`第${i+1}行清理后:`, cols);
                
                // 根据列数创建数据对象
                if (cols.length >= 3) {
                    const rowData = {
                        position: cols[0] || '',
                        education: cols[1] || '',
                        major: cols[2] || ''
                    };
                    
                    // 验证数据是否合理（不是标题行）
                    if (!isHeaderRow(rowData)) {
                        data.push(rowData);
                        console.log(`第${i+1}行添加到结果:`, rowData);
                    } else {
                        console.log(`第${i+1}行识别为标题行，跳过:`, rowData);
                    }
                } else if (cols.length === 2) {
                    const rowData = {
                        position: cols[0] || '',
                        education: cols[1] || '',
                        major: '不限'
                    };
                    
                    if (!isHeaderRow(rowData)) {
                        data.push(rowData);
                        console.log(`第${i+1}行添加到结果(2列):`, rowData);
                    }
                } else if (cols.length === 1 && cols[0]) {
                    // 单列数据，可能是职位名称
                    const rowData = {
                        position: cols[0],
                        education: '不限',
                        major: '不限'
                    };
                    
                    if (!isHeaderRow(rowData)) {
                        data.push(rowData);
                        console.log(`第${i+1}行添加到结果(1列):`, rowData);
                    }
                } else {
                    console.log(`第${i+1}行列数不足，跳过:`, cols);
                }
            }
            
            console.log('解析到的数据:', data.slice(0, 5)); // 显示前5行
            
            if (data.length === 0) {
                // 如果没有解析到数据，返回提示信息
                resolve([
                    {
                        position: '解析失败',
                        education: '无法识别文件格式',
                        major: '请检查文件内容'
                    }
                ]);
            } else {
                resolve(data);
            }
        } catch (error) {
            console.error('文件解析错误:', error);
            // 返回错误提示而不是reject
            resolve([
                {
                    position: '解析错误',
                    education: '文件格式不支持',
                    major: '请上传CSV格式文件'
                }
            ]);
        }
    });
}

// 显示Excel数据
function displayExcelData(data, container) {
    if (!data || data.length === 0) {
        displayFallbackData(container);
        return;
    }
    
    console.log('准备显示数据:', data.length, '条记录');
    
    // 跳过标题行（如果第一行是标题）
    const startIndex = (data[0] && isHeaderRow(data[0])) ? 1 : 0;
    const displayData = data.slice(startIndex);
    
    let tableHtml = `
        <div class="excel-table-container" style="height: 100%; overflow-y: auto;">
            <!-- 置顶提示信息 -->
            <div class="table-notice" style="background: #fff3cd; border: 1px solid #ffeaa7; border-radius: 4px 4px 0 0; padding: 12px; margin: 0; color: #856404; font-size: 14px; text-align: center; position: sticky; top: 0; z-index: 10; border-bottom: none;">
                <strong>注意：</strong>此表为简化版，详情请查看官方原公告。
            </div>
            
            <table class="excel-table" style="width: 100%; border-collapse: collapse; margin: 0;">
                <thead style="position: sticky; top: 49px; z-index: 5; background: #fff;">
                    <tr>
                        <th style="padding: 12px; border: 1px solid #ddd; background: #f8f9fa; font-weight: bold; border-top: none;">职位名称</th>
                        <th style="padding: 12px; border: 1px solid #ddd; background: #f8f9fa; font-weight: bold; border-top: none;">学历要求</th>
                        <th style="padding: 12px; border: 1px solid #ddd; background: #f8f9fa; font-weight: bold; border-top: none;">专业要求</th>
                    </tr>
                </thead>
                <tbody>`;
    
    // 显示所有数据，不限制数量
    for (let i = 0; i < displayData.length; i++) {
        const row = displayData[i];
        const isEvenRow = i % 2 === 0;
        const bgColor = isEvenRow ? '#ffffff' : '#f8f9fa';
        
        tableHtml += `
                    <tr style="background-color: ${bgColor};">
                        <td style="padding: 10px 12px; border: 1px solid #ddd; vertical-align: top;">${escapeHtml(row.position || '')}</td>
                        <td style="padding: 10px 12px; border: 1px solid #ddd; vertical-align: top;">${escapeHtml(row.education || '')}</td>
                        <td style="padding: 10px 12px; border: 1px solid #ddd; vertical-align: top;">${escapeHtml(row.major || '')}</td>
                    </tr>`;
    }
    
    // 在表格底部显示统计信息
    tableHtml += `
                    <tr style="background-color: #e9ecef;">
                        <td colspan="3" style="padding: 12px; border: 1px solid #ddd; text-align: center; font-style: italic; color: #6c757d;">
                            共 ${displayData.length} 个职位
                        </td>
                    </tr>
                </tbody>
            </table>
        </div>
    `;
    
    container.innerHTML = tableHtml;
}

// 判断是否为标题行
function isHeaderRow(rowData) {
    const position = (rowData.position || '').toLowerCase();
    const education = (rowData.education || '').toLowerCase();
    const major = (rowData.major || '').toLowerCase();
    
    // 检查是否包含标题关键词
    const headerKeywords = ['职位名称', '岗位', '学历要求', '学历', '专业要求', '专业', 'position', 'education', 'major'];
    
    return headerKeywords.some(keyword => 
        position.includes(keyword) || 
        education.includes(keyword) || 
        major.includes(keyword)
    );
}

// 显示备用数据（当解析失败时）
function displayFallbackData(container) {
    container.innerHTML = `
        <div class="excel-table-container" style="height: 100%; overflow-y: auto; display: flex; align-items: center; justify-content: center;">
            <!-- 置顶提示信息 -->
            <div style="text-align: center; padding: 40px;">
                <div style="background: #fff3cd; border: 1px solid #ffeaa7; border-radius: 4px; padding: 20px; margin-bottom: 20px; color: #856404;">
                    <strong>注意：</strong>此表为简化版，详情请查看官方原公告。
                </div>
                <div style="color: #6c757d; font-size: 16px;">
                    <strong>文件解析中...</strong>
                </div>
            </div>
        </div>
    `;
}

// 全局暴露关闭函数供 HTML 中调用
window.closePositionDetailsModal = closePositionDetailsModal;
window.loadExcelPreview = loadExcelPreview;

// 特别处理Excel表格格式的解析函数
function parseSpecialExcelFormat(text) {
    // 尝试解析微软表格复制粘贴的内容
    console.log('尝试特殊解析Excel表格');
    
    const lines = text.split(/\r?\n/).filter(line => line.trim());
    if (lines.length === 0) return [];
    
    console.log('总行数:', lines.length);
    console.log('头几行样本:', lines.slice(0, 3));
    
    // 观察分隔符，默认使用制表符
    let delimiter = '\t';
    const firstLine = lines[0];
    
    if (firstLine.includes('\t')) {
        console.log('检测到制表符分隔');
        delimiter = '\t';
    } else if (firstLine.includes(',')) {
        console.log('检测到逗号分隔');
        delimiter = ',';
    }
    
    const result = [];
    let headerRow = null;
    
    // 第一行可能是表头
    const firstLineSplit = firstLine.split(delimiter);
    if (firstLineSplit.length >= 2) {
        const firstCell = firstLineSplit[0].toLowerCase();
        if (firstCell.includes('职位') || firstCell.includes('岗位') || firstCell === 'position') {
            headerRow = firstLineSplit;
            console.log('检测到表头行:', headerRow);
        }
    }
    
    // 处理数据行
    const startIndex = headerRow ? 1 : 0;
    for (let i = startIndex; i < lines.length; i++) {
        const line = lines[i].trim();
        if (!line) continue;
        
        const cols = line.split(delimiter).map(col => col.trim());
        console.log(`行 ${i+1} 分割结果:`, cols);
        
        // 处理列数大于3的情况 - 有可能是特殊格式（如截图中的格式）
        if (cols.length > 3) {
            // 这里特别处理您截图中的格式
            // 根据截图分析，很可能是您的表格是将多个专业合并在一个单元格里
            const position = cols[0];
            const education = cols[1];
            
            // 判断技术或医师在前面几列
            if (position.includes('技师') || position.includes('医师')) {
                // 将剩余列视为专业要求
                const major = cols.slice(2).join(' ');
                result.push({
                    position: position,
                    education: education,
                    major: major
                });
                console.log('多列数据处理:', { position, education, major });
                continue;
            }
        }
        
        // 标准处理
        if (cols.length >= 3) {
            result.push({
                position: cols[0],
                education: cols[1],
                major: cols[2]
            });
        } else if (cols.length === 2) {
            result.push({
                position: cols[0],
                education: cols[1],
                major: '不限'
            });
        } else if (cols.length === 1 && cols[0]) {
            result.push({
                position: cols[0],
                education: '不限',
                major: '不限'
            });
        }
    }
    
    console.log('特殊格式解析完成，共', result.length, '条数据');
    return result;
}

// 检查SheetJS库是否加载成功，如果没有加载成功则使用本地版本
function ensureSheetJSLoaded() {
  return new Promise((resolve) => {
    console.log('开始检查SheetJS库加载状态');
    
    // 首先检查全局XLSX对象是否已存在
    if (typeof XLSX !== 'undefined') {
      console.log('SheetJS库已加载，版本:', XLSX.version || '未知');
      resolve(true);
      return;
    }
    
    console.log('SheetJS库未加载，尝试加载');
    
    // 检查是否在Web环境中
    const isWeb = !window.process || !window.process.type;
    console.log('运行环境检测 - Web:', isWeb);
    
    if (isWeb) {
      console.log('在Web环境中，使用CDN加载本地SheetJS库');
      // 在Web环境中，使用本地xlsx.full.min.js文件
      const script = document.createElement('script');
      script.src = './xlsx.full.min.js';
      script.onload = function() {
        console.log('本地SheetJS库加载成功，版本:', XLSX.version || '未知');
        resolve(true);
      };
      
      script.onerror = function(error) {
        console.error('本地SheetJS库加载失败:', error);
        console.log('尝试使用CDN加载SheetJS库');
        const fallbackScript = document.createElement('script');
        fallbackScript.src = 'https://cdn.jsdelivr.net/npm/xlsx@0.18.5/dist/xlsx.full.min.js';
        fallbackScript.onload = function() {
          console.log('CDN SheetJS库加载成功，版本:', XLSX.version || '未知');
          resolve(true);
        };
        fallbackScript.onerror = function(error) {
          console.error('CDN SheetJS库加载失败:', error);
          resolve(false);
        };
        document.head.appendChild(fallbackScript);
      };
      
      document.head.appendChild(script);
    } else {
      console.log('在浏览器环境中，直接使用CDN加载SheetJS库');
      // 在浏览器环境中，直接使用CDN
      const script = document.createElement('script');
      script.src = 'https://cdn.jsdelivr.net/npm/xlsx@0.18.5/dist/xlsx.full.min.js';
      script.onload = function() {
        console.log('CDN SheetJS库加载成功，版本:', XLSX.version || '未知');
        resolve(true);
      };
      script.onerror = function(error) {
        console.error('CDN SheetJS库加载失败:', error);
        resolve(false);
      };
      document.head.appendChild(script);
    }
  });
}
